/**
 * 笔记控制器
 * 处理笔记相关的业务逻辑
 */
const noteModel = require('../models/noteModel');
const logger = require('../utils/logger');

const noteController = {
  /**
   * 获取笔记列表
   * @param {Object} req - 请求对象
   * @param {Object} res - 响应对象
   * @param {Function} next - 下一个中间件函数
   */
  getNotes: async (req, res, next) => {
    try {
      const userId = req.user.id;
      
      // 提取查询参数
      const filters = {
        search: req.query.search,
        limit: req.query.limit,
        offset: req.query.offset,
        sort: req.query.sort || 'updated_at',
        order: req.query.order || 'desc'
      };

      const notes = await noteModel.findAll(userId, filters);
      
      res.json({
        data: notes,
        count: notes.length
      });
    } catch (error) {
      logger.error(`获取笔记列表错误: ${error.message}`);
      next(error);
    }
  },

  /**
   * 获取单篇笔记
   * @param {Object} req - 请求对象
   * @param {Object} res - 响应对象
   * @param {Function} next - 下一个中间件函数
   */
  getNote: async (req, res, next) => {
    try {
      const noteId = req.params.id;
      const userId = req.user.id;

      const note = await noteModel.findById(noteId, userId);
      
      if (!note) {
        return res.status(404).json({ message: '笔记不存在' });
      }

      res.json({ data: note });
    } catch (error) {
      logger.error(`获取笔记详情错误: ${error.message}`);
      next(error);
    }
  },

  /**
   * 创建笔记
   * @param {Object} req - 请求对象
   * @param {Object} res - 响应对象
   * @param {Function} next - 下一个中间件函数
   */
  createNote: async (req, res, next) => {
    try {
      const userId = req.user.id;
      const noteData = {
        ...req.body,
        user_id: userId
      };

      const newNote = await noteModel.create(noteData);
      
      res.status(201).json({
        message: '笔记创建成功',
        data: newNote
      });
    } catch (error) {
      logger.error(`创建笔记错误: ${error.message}`);
      next(error);
    }
  },

  /**
   * 更新笔记
   * @param {Object} req - 请求对象
   * @param {Object} res - 响应对象
   * @param {Function} next - 下一个中间件函数
   */
  updateNote: async (req, res, next) => {
    try {
      const noteId = req.params.id;
      const userId = req.user.id;
      const updateData = req.body;

      // 检查笔记是否存在
      const existingNote = await noteModel.findById(noteId, userId);
      if (!existingNote) {
        return res.status(404).json({ message: '笔记不存在' });
      }

      const success = await noteModel.update(noteId, userId, updateData);
      
      if (!success) {
        return res.status(400).json({ message: '更新失败' });
      }

      // 获取更新后的笔记
      const updatedNote = await noteModel.findById(noteId, userId);

      res.json({
        message: '笔记已更新',
        data: updatedNote
      });
    } catch (error) {
      logger.error(`更新笔记错误: ${error.message}`);
      next(error);
    }
  },

  /**
   * 删除笔记
   * @param {Object} req - 请求对象
   * @param {Object} res - 响应对象
   * @param {Function} next - 下一个中间件函数
   */
  deleteNote: async (req, res, next) => {
    try {
      const noteId = req.params.id;
      const userId = req.user.id;

      // 检查笔记是否存在
      const existingNote = await noteModel.findById(noteId, userId);
      if (!existingNote) {
        return res.status(404).json({ message: '笔记不存在' });
      }

      const success = await noteModel.delete(noteId, userId);
      
      if (!success) {
        return res.status(400).json({ message: '删除失败' });
      }

      res.json({
        message: '笔记已删除',
        id: noteId
      });
    } catch (error) {
      logger.error(`删除笔记错误: ${error.message}`);
      next(error);
    }
  }
};

module.exports = noteController; 